package org.example;

import java.util.concurrent.LinkedBlockingDeque;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * 通过ThreadExectorPool来手动创建线程池,ThreadPoolExecutor参数解释
 * int corePoolSize：有几个工作线程
 * int maximumPoolSize：最大的工作线程，只有corePoolSize用完且workQueue满了才会把工作线程增加到maximumPoolSize
 * long keepAliveTime：maximumPoolSize-corePoolSize的线程存活时间
 * TimeUnit unit：keepAliveTime的时间单位
 * BlockingQueue<Runnable> workQueue：corePoolSize数量达到后的排队队列
 * ThreadFactory threadFactory：线程创建方式
 * RejectedExecutionHandler handler： maximumPoolSize用完且workQueue满了后的处理方式
 */
public class FirstThreadPoolExecutorDemo
{
    public static void main( String[] args )
    {
        /*
          通过注释executorPool.execute(new Runnable() ...)代码段，控制工作量。
          1.如果实际工作有2连个输出如下：
            工作线程数：1
            排队线程数：1
            所有工作都完成，这个证明了maximumPoolSize的使用条件：corePoolSize用完且workQueue满了才会继续创建工作线程，直到maximumPoolSize
          2.如果实际工作有3连个输出如下：
            工作线程数：2
            排队线程数：1
            所有工作都完成
          3.如果实际工作有4连个输出如下：
            工作线程数：2
            排队线程数：1
            有一个工作因为DiscardPolicy设置会被忽略，没有被打印出来
         */
        ThreadPoolExecutor executorPool = new ThreadPoolExecutor(
                1,
                2,
                500,
                TimeUnit.SECONDS,
                new LinkedBlockingDeque<Runnable>(1),
                new ThreadFactory(){
                    @Override
                    public Thread newThread(Runnable r){
                        Thread t = new Thread(r);
                        t.setName(t.getId()+"test");
                        return t;
                    }
                },
                new ThreadPoolExecutor.DiscardPolicy()
        );

        executorPool.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + " hello world1");
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

            }
        });

        executorPool.execute(new Runnable() {
            public void run() {
                System.out.println(Thread.currentThread().getName() + " hello world2");
                try {
                    Thread.sleep(10000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
//        executorPool.execute(new Runnable() {
//            public void run() {
//                System.out.println(Thread.currentThread().getName() + " hello world3");
//                try {
//                    Thread.sleep(10000);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//            }
//        });
//        executorPool.execute(new Runnable() {
//            public void run() {
//                System.out.println(Thread.currentThread().getName() + " hello world4");
//                try {
//                    Thread.sleep(10000);
//                } catch (InterruptedException e) {
//                    throw new RuntimeException(e);
//                }
//            }
//        });
        System.out.println("工作线程数：" + executorPool.getActiveCount());
        System.out.println("排队线程数：" + executorPool.getQueue().size());
        executorPool.shutdown();
    }
}
